﻿#define _CRT_SECURE_NO_WARNINGS 1
#include"SepList.h"


void test()
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPrint(&sl);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPushBack(&sl, 7);
	SLPushBack(&sl, 8);
	SLPrint(&sl);
	SLPushFront(&sl, 9);
	SLPrint(&sl);
}

void test1()
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPrint(&sl);
	SLPopBack(&sl);
	SLPrint(&sl);
}

void test2()
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPrint(&sl);
	SLInsert(&sl, 3, 40);
	SLPrint(&sl);

	
}

void test3()
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPrint(&sl);
	int x, y;
	printf("请输入要删除的数：\n");
	scanf("%d", &x);
	int pos = SLFind(&sl, x);
	while (pos != -1)
	{
		SLErase(&sl, pos);
		pos = SLFind(&sl, x);
	}
	SLPrint(&sl);

	printf("请输入要修改的数的坐标和内容：\n");
	scanf("%d%d", &x,&y);
	SLModify(&sl, pos, 3);
	SLPrint(&sl);
}


void menu()
{
	printf("***********************\n");
	printf("1.头插         2.尾插\n");
	printf("3.头删         4.尾删\n");
	printf("5.插入数据     6.删除数据\n");
	printf("7.查找         8.修改\n");
	printf("9.打印         0.退出\n");
	printf("***********************\n");
}

//int main()
//{
//	int input = 0;
//	SL sl;
//	SLInit(&sl);
//	do
//	{
//		menu();
//		printf("请选择：\n");
//		//if (scanf("%d", &input) == 0)
//		//{
//		//	char ch;
//		//	printf("输入错误，请重新输入：\n");
//		//	while (getchar() != '\n')
//		//	{
//		//		continue;
//		//	}
//		//	continue;
//		//}
//		while (scanf("%d", &input) == 0)
//		{
//			printf("输入错误，请重新输入：\n");
//			while (getchar() != '\n')
//				{
//					continue;
//				}
//		}
//		switch (input)
//		{
//			SLDataType x;
//			int pos;
//		case 1:
//			printf("请输入要插入的数据：\n");
//			scanf("%d", &x);
//			SLPushFront(&sl, x);
//			CASE 2:
//			printf("请输入要插入的数据：\n");
//			scanf("%d", &x);
//			SLPushBack(&sl, x);
//			CASE 3:
//			SLPopFront(&sl);
//			CASE 4:
//			SLPopBack(&sl);
//			CASE 5:
//			printf("请输入要插入的数据和坐标：\n");
//			scanf("%d%d", &x,&pos);
//			SLInsert(&sl, pos, x);
//			CASE 6:
//			printf("请输入要插入的坐标：\n");
//			scanf("%d", &pos);
//			SLErase(&sl, pos);
//			CASE 7:
//			printf("请输入要查找的数据：\n");
//			scanf("%d", &x);
//			pos = SLFind(&sl, x);
//			printf("下标为：%d\n", pos);
//			CASE 8:
//			printf("请输入要修改的数据和坐标：\n");
//			scanf("%d%d", &x, &pos);
//			SLModify(&sl, pos, x);
//			CASE 9:
//			SLPrint(&sl);
//			CASE 0:
//			printf("退出\n");
//			break;
//		default:
//			printf("输入错误，请重新输入：\n");
//			break;
//		}
//	} while (input);
//	SLDestory(&sl);
//	return 0;
//}

//作业

//给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
//不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
//元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

//说明:
//为什么返回数值是整数，但输出的答案是数组呢 ?
//请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
//你可以想象内部操作如下 :
//// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
//int len = removeElement(nums, val);
//// 在函数里修改输入数组对于调用者是可见的。
//// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
//for (int i = 0; i < len; i++) {
//	print(nums[i]);
//}


//int removeElement(int* nums, int numsSize, int val) 
//{
//	int src = 0, dest = 0;
//	while (src < numsSize)
//	{
//		if (nums[src] == val)
//		{
//			src++;
//		}
//		else
//		{
//			nums[dest++] = nums[src++];
//		}
//	}
//	return dest;
//}


//给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，
//返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
//考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
//更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。
//nums 的其余元素与 nums 的大小不重要。
//返回 k 。
//判题标准 :
//系统会用下面的代码来测试你的题解:
//int[] nums = [...]; // 输入数组
//int[] expectedNums = [...]; // 长度正确的期望答案
//int k = removeDuplicates(nums); // 调用
//assert k == expectedNums.length;
//for (int i = 0; i < k; i++) {
//	assert nums[i] == expectedNums[i];
//}
//如果所有断言都通过，那么您的题解将被 通过。


//int removeDuplicates(int* nums, int numsSize) 
//{
//	if (numsSize <= 1)
//	{
//		return numsSize;
//	}
//	int src = 1, dest = 1;
//	int tmp = nums[0];
//	while (src < numsSize)
//	{
//		if (nums[src] == tmp)
//		{
//			src++;
//		}
//		else
//		{
//			tmp = nums[src];
//			nums[dest++] = nums[src++];
//		}
//	}
//	return dest;
//}




//给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，
// 分别表示 nums1 和 nums2 中的元素数目。
//
//请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
//
//注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。
//为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。
//nums2 的长度为 n 。

//void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
//	int end1 = m - 1;
//	int end2 = n - 1;
//	int end = m + n - 1;
//	while (end1 >= 0 && end2 >= 0)
//	{
//		if (nums2[end2] >= nums1[end1])
//		{
//			nums1[end--] = nums2[end2--];
//		}
//		else
//		{
//			nums1[end--] = nums1[end1--];
//		}
//	}
//	while (end2 >= 0)
//	{
//		nums1[end--] = nums2[end2--];
//	}
//}

//给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
//
//void reserve(int* nums, int left, int right)
//{
//	while (left < right)
//	{
//		int tmp = nums[left];
//		nums[left] = nums[right];
//		nums[right] = tmp;
//		left++;
//		right--;
//	}
//}
//
//void rotate(int* nums, int numsSize, int k) {
//	k = k % numsSize;
//	reserve(nums, numsSize - k, numsSize - 1);
//	reserve(nums, 0, numsSize - k - 1);
//	reserve(nums, 0, numsSize - 1);
//}



//整数的 数组形式  num 是按照从左到右的顺序表示其数字的数组。
//
//例如，对于 num = 1321 ，数组形式是[1, 3, 2, 1] 。
//给定 num ，整数的 数组形式 ，和整数 k ，返回 整数 num + k 的 数组形式 。

//int* addToArrayForm(int* num, int numSize, int k, int* returnSize) {
//
//	int n = 0;
//	int i = 0;
//	for (i = 0; i < numSize; i++)
//	{
//		n = num[i]  + n * 10;
//	}
//	n = n + k;
//	int y = n;
//	i = 0;
//	while (n)
//	{
//		n = n / 10;
//		i++;
//	}
//	*returnSize = i;
//	int* p = (int*)malloc(sizeof(int) * i);
//	while (i)
//	{
//		p[i - 1] = y % 10;
//		y = y / 10;
//		i--;
//	}
//	return p;
//}


//int* addToArrayForm(int* num, int numSize, int k, int* returnSize) {
//	int x = 0;
//	while (k)
//	{
//		num[numSize - x - 1] += k % 10;
//		x++;
//		k /= 10;
//	}
//	if (*num > 10)
//	{
//		x = numSize + 1;
//	}
//	else
//	{
//		x = numSize;
//	}
//	*returnSize = x;
//	int* p = (int*)malloc(sizeof(int) * x);
//	
//	while (x)
//	{
//		if (num[x - 1] >= 10)
//		{
//			p[x - 1] = num[x - 1] % 10;
//			num[x]++;
//			x--;
//		}
//		else
//		{
//			p[x - 1] = num[x - 1];
//			x--;
//		}
//	}
//	return p;
//}
//int main()
//{
//	int num[] = { 1,2,0,0 };
//	int p = 0;
//	addToArrayForm(num, 4, 34, &p);
//	return 0;
//}

//void reserve(int* left, int* right)
//{
//	while (left < right)
//	{
//		int tmp = *left;
//		*left = *right;
//		*right = tmp;
//		left++;
//		right--;
//	}
//}
//
//int* addToArrayForm(int* num, int numSize, int k, int* returnSize)
//{
//	int a = 0;
//	int* p = (int*)calloc(numSize + 1, sizeof(int));
//	reserve(num, num + numSize - 1);
//	while (k)
//	{
//		num[a] += k % 10;
//		if (num[a] >= 10)
//		{
//			num[++a] += 1;
//		}
//		else
//		{
//			a++;
//		}
//		k /= 10;
//	}
//}


//博客演示

////顺序表的静态存储
//#define N 8
//typedef int SLDataType;
//typedef struct SepList
//{
//	SLDataType array[N]; //定长数组
//
//	size_t size;      //有效数据的个数
//	
//}SepList;
//
//
//
////顺序表的动态存储
//typedef struct SepList
//{
//	SLDataType* array; //指向动态开辟的数组
//	size_t size;      //有效数据的个数
//	size_t capicity;  //容量空间的大小 
//}SepList;



//typedef int SLDataType;
//// 顺序表的动态存储
//typedef struct SeqList
//{
//	SLDataType* array; // 指向动态开辟的数组
//	size_t size; // 有效数据个数
//	size_t capicity; // 容量空间的大小
//}SeqList;
//
//// 基本增删查改接口
//// 顺序表初始化
//void SeqListInit(SeqList* psl, size_t capacity);
//// 检查空间，如果满了，进行增容
//void CheckCapacity(SeqList* psl);
//// 顺序表尾插
//void SeqListPushBack(SeqList* psl, SLDataType x);
//// 顺序表尾删
//void SeqListPopBack(SeqList* psl);
//// 顺序表头插
//void SeqListPushFront(SeqList* psl, SLDataType x);
//// 顺序表头删
//void SeqListPopFront(SeqList* psl);
//// 顺序表查找
//int SeqListFind(SeqList* psl, SLDataType x);
//// 顺序表在pos位置插入x
//void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
//// 顺序表删除pos位置的值
//void SeqListErase(SeqList* psl, size_t pos);
//// 顺序表销毁
//void SeqListDestory(SeqList* psl);
//// 顺序表打印
//void SeqListPrint(SeqList* psl);





//作业
//void reserve(int* left, int* right)
//{
//	while (left < right)
//	{
//		int tmp = *left;
//		*left = *right;
//		*right = tmp;
//		left++;
//		right--;
//	}
//
//}
//int* addToArrayForm(int* num, int numSize, int k, int* returnSize) {
//	int size = 0;
//	int i = k;
//	while (i)
//	{
//		i /= 10;
//		size++;
//	}
//	if (size < numSize)
//	{
//		size = numSize;
//	}
//	int* arr = (int*)calloc((size + 1), sizeof(int));
//	reserve(num, num + numSize - 1);
//	while (k)
//	{
//		arr[i] = k % 10;
//		k = k / 10;
//		i++;
//	}
//	for (i = 0; i < numSize; i++)
//	{
//		arr[i] = num[i] + arr[i];
//	}
//	for (i = 0; i < size; i++)
//	{
//		if (arr[i] >= 10)
//		{
//			arr[i] = arr[i] % 10;
//			arr[i + 1] += 1;
//		}
//	}
//
//	if (arr[size])
//	{
//		reserve(arr, arr + size);
//		*returnSize = size + 1;
//		return arr;
//	}
//	else
//	{
//		int* brr = (int*)malloc(size * sizeof(int));
//		for (i = 0; i < size; i++)
//		{
//			brr[i] = arr[i];
//		}
//		free(arr);
//		arr = NULL;
//		reserve(brr, brr + size - 1);
//		*returnSize = size;
//		return brr;
//	}
//}
//
//
//int main()
//{
//	int num[] = { 1,2,0,0 };
//	int k = 34;
//	int returnsize = 0;
//	int* a = addToArrayForm(num, 4, k, &returnsize);
//	for (int i = 0; i < 4; i++)
//	{
//		printf("%d ", a[i]);
//	}
//	return 0;
//}